/**
 * 设置页面事件处理器
 * 负责处理设置页面相关的所有事件和逻辑
 */
class SetupHandler {
    constructor(appState, apiService, uiUtils) {
        this.appState = appState;
        this.apiService = apiService;
        this.uiUtils = uiUtils;
    }

    /**
     * 初始化设置页面
     */
    async init() {
        console.log('[SetupHandler] 初始化设置页面');
        
        // 延迟执行，确保 DOM 完全加载
        setTimeout(async () => {
            this.setupProviderTabs();
            this.bindEvents();
            await this.loadSavedConfig(); // 加载已保存的配置
            await this.loadAppInfo(); // 加载应用信息
        }, 100);
    }

    /**
     * 加载应用信息
     */
    async loadAppInfo() {
        try {
            console.log('[SetupHandler] 加载应用信息');
            
            // 获取应用信息
            const appInfo = await window.electronAPI.invoke('app:get-info');
            
            // 更新版本显示
            const currentVersion = document.getElementById('current-version');
            if (currentVersion && appInfo) {
                currentVersion.textContent = `v${appInfo.version}`;
            }
            
            // 设置更新时间（使用构建时间或当前时间）
            const updateTime = document.getElementById('update-time');
            if (updateTime) {
                updateTime.textContent = new Date().toLocaleDateString('zh-CN');
            }
        } catch (error) {
            console.error('[SetupHandler] 加载应用信息失败:', error);
        }
    }

    /**
     * 加载已保存的配置
     */
    async loadSavedConfig() {
        try {
            console.log('[SetupHandler] 加载已保存的配置');
            
            const result = await window.electronAPI.invoke('storage:load-model-config');
            
            if (result.success && result.config) {
                const { provider, model, apiKey } = result.config;
                
                // 如果有保存的配置，则填充到界面
                if (provider && model && apiKey) {
                    console.log('[SetupHandler] 找到已保存的配置:', { provider, model });
                    
                    // 切换到对应的厂商标签
                    document.querySelectorAll('.provider-tab').forEach(tab => {
                        tab.classList.remove('active');
                        if (tab.getAttribute('data-provider') === provider) {
                            tab.classList.add('active');
                        }
                    });
                    
                    // 更新模型选择器
                    this.updateModelSelector(provider);
                    
                    // 等待模型选择器更新完成后设置选中的模型
                    setTimeout(() => {
                        const modelSelect = document.getElementById('model-select');
                        const apiKeyInput = document.getElementById('api-key-input');
                        
                        if (modelSelect) {
                            modelSelect.value = model;
                        }
                        
                        if (apiKeyInput) {
                            apiKeyInput.value = apiKey;
                        }
                    }, 50);
                    
                    // 更新应用状态
                    this.appState.provider = provider;
                    this.appState.model = model;
                    this.appState.apiKey = apiKey;
                }
            }
        } catch (error) {
            console.error('[SetupHandler] 加载配置失败:', error);
        }
    }

    /**
     * 设置厂商标签页事件
     */
    setupProviderTabs() {
        console.log('[SetupHandler] 设置厂商标签页事件');
        
        // 移除旧的事件监听器
        document.querySelectorAll('.provider-tab').forEach(tab => {
            tab.replaceWith(tab.cloneNode(true));
        });

        // 重新绑定事件
        document.querySelectorAll('.provider-tab').forEach(tab => {
            tab.addEventListener('click', (event) => {
                const provider = event.currentTarget.getAttribute('data-provider');
                this.handleProviderSwitch(provider);
            });
        });

        // 初始化默认选中的厂商
        const activeTab = document.querySelector('.provider-tab.active');
        if (activeTab) {
            const defaultProvider = activeTab.getAttribute('data-provider');
            this.updateModelSelector(defaultProvider);
        }
    }

    /**
     * 处理厂商切换
     * @param {string} provider - 厂商名称
     */
    handleProviderSwitch(provider) {
        console.log('[SetupHandler] 切换厂商:', provider);
        
        // 更新标签页状态
        document.querySelectorAll('.provider-tab').forEach(tab => {
            tab.classList.remove('active');
        });
        document.querySelector(`[data-provider="${provider}"]`).classList.add('active');

        // 更新模型选择器
        this.updateModelSelector(provider);
    }

    /**
     * 更新模型选择器
     * @param {string} provider - 厂商名称
     */
    updateModelSelector(provider) {
        const modelSelect = document.getElementById('model-select');
        if (!modelSelect) return;

        // 清空现有选项
        modelSelect.innerHTML = '<option value="">请先选择模型厂商</option>';

        // 根据厂商添加模型选项
        const models = this.getModelsByProvider(provider);
        models.forEach(model => {
            const option = document.createElement('option');
            option.value = model.value;
            option.textContent = model.name;
            modelSelect.appendChild(option);
        });
    }

    /**
     * 根据厂商获取模型列表
     * @param {string} provider - 厂商名称
     * @returns {Array} 模型列表
     */
    getModelsByProvider(provider) {
        const modelMap = {
            deepseek: [
                { value: 'deepseek-v3.1', name: 'DeepSeek V3.1 (最新混合架构)' },
                { value: 'deepseek-v3', name: 'DeepSeek V3 (MoE架构)' },
                { value: 'deepseek-r1', name: 'DeepSeek R1 (推理模型)' },
                { value: 'deepseek-r1-distill', name: 'DeepSeek R1 Distill (蒸馏版)' },
                { value: 'deepseek-coder', name: 'DeepSeek Coder (代码专用)' },
                { value: 'deepseek-vl2', name: 'DeepSeek VL2 (视觉语言)' },
                { value: 'deepseek-math', name: 'DeepSeek Math (数学专用)' }
            ],
            zhipu: [
                { value: 'glm-4', name: 'GLM-4 (最新版本)' },
                { value: 'glm-4v', name: 'GLM-4V (视觉版本)' },
                { value: 'glm-3-turbo', name: 'GLM-3 Turbo' },
                { value: 'chatglm3-6b', name: 'ChatGLM3-6B (开源版)' },
                { value: 'chatglm2-6b', name: 'ChatGLM2-6B (开源版)' },
                { value: 'chatglm-6b', name: 'ChatGLM-6B (开源版)' }
            ],
            gemini: [
                { value: 'gemini-1.5-pro', name: 'Gemini 1.5 Pro (最新专业版)' },
                { value: 'gemini-1.5-flash', name: 'Gemini 1.5 Flash (快速版)' },
                { value: 'gemini-pro', name: 'Gemini Pro (专业版)' },
                { value: 'gemini-pro-vision', name: 'Gemini Pro Vision (视觉版)' },
                { value: 'gemini-nano', name: 'Gemini Nano (轻量版)' }
            ]
        };

        return modelMap[provider] || [];
    }

    /**
     * 处理网站注册按钮点击
     */
    handleRegisterClick() {
        console.log('[SetupHandler] 处理网站注册按钮点击');
        
        const activeTab = document.querySelector('.provider-tab.active');
        if (!activeTab) {
            console.log('[SetupHandler] 未找到选中的厂商标签页');
            return;
        }

        const provider = activeTab.getAttribute('data-provider');
        console.log('[SetupHandler] 当前选中的厂商:', provider);
        
        const urls = {
            deepseek: 'https://platform.deepseek.com/',
            zhipu: 'https://open.bigmodel.cn/',
            gemini: 'https://aistudio.google.com/'
        };

        const url = urls[provider];
        if (url) {
            console.log('[SetupHandler] 打开注册页面:', url);
            window.open(url, '_blank');
        } else {
            console.log('[SetupHandler] 未找到厂商对应的注册URL');
        }
    }

    /**
     * 处理保存配置
     */
    async handleSaveConfig() {
        console.log('[SetupHandler] 处理保存配置');
        
        const activeTab = document.querySelector('.provider-tab.active');
        const modelSelect = document.getElementById('model-select');
        const apiKeyInput = document.getElementById('api-key-input');

        if (!activeTab || !modelSelect || !apiKeyInput) {
            console.log('[SetupHandler] 缺少必要的DOM元素');
            return;
        }

        const provider = activeTab.getAttribute('data-provider');
        const model = modelSelect.value;
        const apiKey = apiKeyInput.value.trim();

        console.log('[SetupHandler] 配置信息:', { provider, model, apiKey });

        // 验证输入
        if (!provider) {
            this.uiUtils.showMessage('请选择模型厂商', 'error');
            return;
        }

        if (!model) {
            this.uiUtils.showMessage('请选择模型', 'error');
            return;
        }

        if (!apiKey) {
            this.uiUtils.showMessage('请输入 API Key', 'error');
            return;
        }

        try {
            this.uiUtils.showLoading('正在保存配置...');

            // 调用 IPC 保存配置到本地存储
            const result = await window.electronAPI.invoke('storage:save-model-config', {
                provider,
                model,
                apiKey
            });

            this.uiUtils.hideLoading();

            if (result.success) {
                this.uiUtils.showMessage('配置保存成功', 'success');
                
                // 更新应用状态
                this.appState.apiKey = apiKey;
                this.appState.provider = provider;
                this.appState.model = model;
                
                // 清除首页的连接测试缓存，下次返回首页时会重新测试
                if (window.homeHandler && typeof window.homeHandler.clearConnectionTestCache === 'function') {
                    window.homeHandler.clearConnectionTestCache();
                    console.log('[SetupHandler] 已清除首页连接测试缓存');
                }
                
                console.log('[SetupHandler] 配置保存成功，已保存到:', result.config);
            } else {
                this.uiUtils.showMessage(`保存失败: ${result.message}`, 'error');
            }

        } catch (error) {
            console.error('[SetupHandler] 保存配置失败:', error);
            
            this.uiUtils.hideLoading();
            this.uiUtils.showMessage(`保存失败: ${error.message}`, 'error');
        }
    }

    /**
     * 处理连接性测试
     */
    async handleTestConnection() {
        console.log('[SetupHandler] 开始连接性测试');
        
        const activeTab = document.querySelector('.provider-tab.active');
        const modelSelect = document.getElementById('model-select');
        const apiKeyInput = document.getElementById('api-key-input');
        const testBtn = document.getElementById('test-connection-btn');
        const statusIndicator = document.getElementById('status-indicator');
        const statusText = document.getElementById('status-text');

        if (!activeTab || !modelSelect || !apiKeyInput || !testBtn || !statusIndicator || !statusText) {
            console.log('[SetupHandler] 缺少必要的DOM元素');
            return;
        }

        const provider = activeTab.getAttribute('data-provider');
        const model = modelSelect.value;
        const apiKey = apiKeyInput.value.trim();

        // 验证输入
        if (!provider) {
            this.updateConnectionStatus('error', '请先选择模型厂商');
            return;
        }

        if (!model) {
            this.updateConnectionStatus('error', '请先选择模型');
            return;
        }

        if (!apiKey) {
            this.updateConnectionStatus('error', '请先输入API Key');
            return;
        }

        try {
            // 更新按钮状态为测试中
            testBtn.disabled = true;
            testBtn.innerHTML = '<i class="fas fa-spinner fa-spin"></i> 测试中...';
            this.updateConnectionStatus('testing', '正在测试连接...');

            console.log('[SetupHandler] 测试参数:', {
                provider,
                model,
                apiKey: apiKey ? '***' + apiKey.slice(-4) : 'none',
                apiKeyLength: apiKey ? apiKey.length : 0
            });

            // 使用公共方法测试连接
            const testResult = await this.apiService.testApiConnection(apiKey, provider, model);
            
            console.log('[SetupHandler] 测试结果:', JSON.stringify(testResult, null, 2));

            if (testResult.success) {
                console.log('[SetupHandler] ✅ 连接测试成功');
                this.updateConnectionStatus('connected', '连接成功');
                this.uiUtils.showMessage('连接测试成功！', 'success');
                
                // 连接测试成功后，自动保存配置
                const saveResult = await window.electronAPI.invoke('storage:save-model-config', {
                    provider,
                    model,
                    apiKey
                });
                
                if (saveResult.success) {
                    console.log('[SetupHandler] 配置已自动保存');
                    // 更新应用状态
                    this.appState.provider = provider;
                    this.appState.model = model;
                    this.appState.apiKey = apiKey;
                    
                    // 清除首页的连接测试缓存，下次返回首页时会重新测试
                    if (window.homeHandler && typeof window.homeHandler.clearConnectionTestCache === 'function') {
                        window.homeHandler.clearConnectionTestCache();
                        console.log('[SetupHandler] 已清除首页连接测试缓存');
                    }
                }
            } else {
                console.error('[SetupHandler] ❌ 连接测试失败');
                console.error('[SetupHandler] 失败原因:', testResult.message);
                console.error('[SetupHandler] 错误来源:', testResult.source || 'unknown');
                console.error('[SetupHandler] 完整结果:', testResult);
                
                this.updateConnectionStatus('disconnected', '连接失败');
                this.uiUtils.showMessage(`连接测试失败: ${testResult.message}`, 'error');
            }

        } catch (error) {
            console.error('[SetupHandler] 连接性测试异常:', error);
            console.error('[SetupHandler] 错误堆栈:', error.stack);
            this.updateConnectionStatus('disconnected', '测试异常');
            this.uiUtils.showMessage(`连接测试异常: ${error.message}`, 'error');
        } finally {
            // 恢复按钮状态
            testBtn.disabled = false;
            testBtn.innerHTML = '<i class="fas fa-wifi"></i> 测试连接';
        }
    }


    /**
     * 更新连接状态显示
     * @param {string} status - 状态类型 (connected, disconnected, testing, error, unknown)
     * @param {string} message - 状态消息
     */
    updateConnectionStatus(status, message) {
        const statusIndicator = document.getElementById('status-indicator');
        const statusText = document.getElementById('status-text');

        if (!statusIndicator || !statusText) return;

        // 移除所有状态类
        statusIndicator.classList.remove('connected', 'disconnected', 'testing', 'unknown');
        
        // 添加新的状态类
        statusIndicator.classList.add(status);
        
        // 更新状态文本
        statusText.textContent = message;

        console.log('[SetupHandler] 连接状态更新:', { status, message });
    }

    /**
     * 处理检测升级
     */
    async handleCheckUpdate() {
        console.log('[SetupHandler] 开始检测升级');
        
        const checkUpdateBtn = document.getElementById('check-update-btn');
        const updateIndicator = document.getElementById('update-indicator');
        const updateText = document.getElementById('update-text');
        const updateDetails = document.getElementById('update-details');

        if (!checkUpdateBtn || !updateIndicator || !updateText) {
            console.log('[SetupHandler] 缺少必要的DOM元素');
            return;
        }

        try {
            // 更新按钮状态为检测中
            checkUpdateBtn.disabled = true;
            checkUpdateBtn.innerHTML = '<i class="fas fa-spinner fa-spin"></i> 检测中...';
            
            // 更新状态显示
            updateIndicator.innerHTML = '<i class="fas fa-spinner fa-spin"></i>';
            updateText.textContent = '正在检测最新版本...';
            
            // 隐藏更新详情
            if (updateDetails) {
                updateDetails.style.display = 'none';
            }

            // 调用 IPC 检测升级
            const result = await window.electronAPI.invoke('app:check-update');
            
            if (result.success) {
                if (result.hasUpdate) {
                    // 有新版本
                    updateIndicator.innerHTML = '<i class="fas fa-exclamation-circle" style="color: #22c55e;"></i>';
                    updateText.textContent = `发现新版本 ${result.latestVersion}`;
                    
                    // 显示更新详情
                    if (updateDetails) {
                        updateDetails.style.display = 'block';
                        const latestVersionSpan = document.getElementById('latest-version');
                        const updateChangelog = document.getElementById('update-changelog');
                        
                        if (latestVersionSpan) {
                            latestVersionSpan.textContent = result.latestVersion;
                        }
                        
                        if (updateChangelog) {
                            updateChangelog.innerHTML = result.changelog || '暂无更新说明';
                        }
                    }
                    
                    this.uiUtils.showMessage('发现新版本！', 'success');
                } else {
                    // 已是最新版本
                    updateIndicator.innerHTML = '<i class="fas fa-check-circle" style="color: #22c55e;"></i>';
                    updateText.textContent = '当前已是最新版本';
                    this.uiUtils.showMessage('当前已是最新版本', 'success');
                }
            } else {
                // 检测失败
                updateIndicator.innerHTML = '<i class="fas fa-times-circle" style="color: #ef4444;"></i>';
                updateText.textContent = '检测失败，请稍后重试';
                this.uiUtils.showMessage(`检测升级失败: ${result.message}`, 'error');
            }

        } catch (error) {
            console.error('[SetupHandler] 检测升级失败:', error);
            
            updateIndicator.innerHTML = '<i class="fas fa-times-circle" style="color: #ef4444;"></i>';
            updateText.textContent = '检测异常';
            this.uiUtils.showMessage(`检测升级异常: ${error.message}`, 'error');
        } finally {
            // 恢复按钮状态
            checkUpdateBtn.disabled = false;
            checkUpdateBtn.innerHTML = '<i class="fas fa-sync-alt"></i> 检测升级';
        }
    }

    /**
     * 处理下载更新
     */
    handleDownloadUpdate() {
        console.log('[SetupHandler] 处理下载更新');
        
        // 打开 GitHub Releases 页面或下载页面
        const downloadUrl = 'https://github.com/your-username/claude-code-agent/releases/latest';
        window.open(downloadUrl, '_blank');
        
        this.uiUtils.showMessage('已打开下载页面', 'success');
    }

    /**
     * 处理关闭更新详情
     */
    handleCloseUpdate() {
        const updateDetails = document.getElementById('update-details');
        if (updateDetails) {
            updateDetails.style.display = 'none';
        }
    }

    /**
     * 绑定设置页面事件
     */
    bindEvents() {
        // 注册按钮
        this.bindButton('register-btn', this.handleRegisterClick.bind(this));
        
        // 保存配置按钮
        this.bindButton('save-config-btn', this.handleSaveConfig.bind(this));
        
        // 连接性测试按钮
        this.bindButton('test-connection-btn', this.handleTestConnection.bind(this));
        
        // 检测升级按钮
        this.bindButton('check-update-btn', this.handleCheckUpdate.bind(this));
        
        // 下载更新按钮
        this.bindButton('download-update-btn', this.handleDownloadUpdate.bind(this));
        
        // 关闭更新详情按钮
        this.bindButton('close-update-btn', this.handleCloseUpdate.bind(this));
    }

    /**
     * 绑定按钮事件
     * @param {string} buttonId - 按钮 ID
     * @param {Function} handler - 事件处理器
     */
    bindButton(buttonId, handler) {
        const button = document.getElementById(buttonId);
        if (button) {
            button.addEventListener('click', handler);
        }
    }

    /**
     * 清理事件监听器
     */
    cleanup() {
        // 移除所有事件监听器
        const buttons = ['register-btn', 'save-config-btn', 'test-connection-btn'];
        buttons.forEach(buttonId => {
            const button = document.getElementById(buttonId);
            if (button) {
                button.replaceWith(button.cloneNode(true));
            }
        });

        // 清理厂商标签页事件
        document.querySelectorAll('.provider-tab').forEach(tab => {
            tab.replaceWith(tab.cloneNode(true));
        });
    }
}

// 导出到全局
window.SetupHandler = SetupHandler;
